home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / glibc-1.09 / glibc-1 / glibc-1.09.1 / sunrpc / clnt_perr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-18  |  6.5 KB  |  306 lines
  1. /* @(#)clnt_perror.c    2.1 88/07/29 4.0 RPCSRC */
  2. /*
  3.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  4.  * unrestricted use provided that this legend is included on all tape
  5.  * media and as a part of the software program in whole or part.  Users
  6.  * may copy or modify Sun RPC without charge, but are not authorized
  7.  * to license or distribute it to anyone else except as part of a product or
  8.  * program developed by the user.
  9.  * 
  10.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  11.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  12.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  13.  * 
  14.  * Sun RPC is provided with no support and without any obligation on the
  15.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  16.  * modification or enhancement.
  17.  * 
  18.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  19.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  20.  * OR ANY PART THEREOF.
  21.  * 
  22.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  23.  * or profits or other special, indirect and consequential damages, even if
  24.  * Sun has been advised of the possibility of such damages.
  25.  * 
  26.  * Sun Microsystems, Inc.
  27.  * 2550 Garcia Avenue
  28.  * Mountain View, California  94043
  29.  */
  30. #if !defined(lint) && defined(SCCSIDS)
  31. static char sccsid[] = "@(#)clnt_perror.c 1.15 87/10/07 Copyr 1984 Sun Micro";
  32. #endif
  33.  
  34. /*
  35.  * clnt_perror.c
  36.  *
  37.  * Copyright (C) 1984, Sun Microsystems, Inc.
  38.  *
  39.  */
  40. #include <stdio.h>
  41.  
  42. #include <rpc/types.h>
  43. #include <rpc/auth.h>
  44. #include <rpc/clnt.h>
  45.  
  46. extern char *sys_errlist[];
  47. /* extern char *sprintf(); --roland@gnu */
  48. static char *auth_errmsg();
  49.  
  50. extern char *strcpy();
  51.  
  52. static char *buf;
  53.  
  54. static char *
  55. _buf()
  56. {
  57.  
  58.     if (buf == 0)
  59.         buf = (char *)malloc(256);
  60.     return (buf);
  61. }
  62.  
  63. /*
  64.  * Print reply error info
  65.  */
  66. char *
  67. clnt_sperror(rpch, s)
  68.     CLIENT *rpch;
  69.     char *s;
  70. {
  71.     struct rpc_err e;
  72.     void clnt_perrno();
  73.     char *err;
  74.     char *str = _buf();
  75.     char *strstart = str;
  76.  
  77.     if (str == 0)
  78.         return (0);
  79.     CLNT_GETERR(rpch, &e);
  80.  
  81.     (void) sprintf(str, "%s: ", s);  
  82.     str += strlen(str);
  83.  
  84.     (void) strcpy(str, clnt_sperrno(e.re_status));  
  85.     str += strlen(str);
  86.  
  87.     switch (e.re_status) {
  88.     case RPC_SUCCESS:
  89.     case RPC_CANTENCODEARGS:
  90.     case RPC_CANTDECODERES:
  91.     case RPC_TIMEDOUT:     
  92.     case RPC_PROGUNAVAIL:
  93.     case RPC_PROCUNAVAIL:
  94.     case RPC_CANTDECODEARGS:
  95.     case RPC_SYSTEMERROR:
  96.     case RPC_UNKNOWNHOST:
  97.     case RPC_UNKNOWNPROTO:
  98.     case RPC_PMAPFAILURE:
  99.     case RPC_PROGNOTREGISTERED:
  100.     case RPC_FAILED:
  101.         break;
  102.  
  103.     case RPC_CANTSEND:
  104.     case RPC_CANTRECV:
  105.         (void) sprintf(str, "; errno = %s",
  106.             sys_errlist[e.re_errno]); 
  107.         str += strlen(str);
  108.         break;
  109.  
  110.     case RPC_VERSMISMATCH:
  111.         (void) sprintf(str,
  112.             "; low version = %lu, high version = %lu", 
  113.             e.re_vers.low, e.re_vers.high);
  114.         str += strlen(str);
  115.         break;
  116.  
  117.     case RPC_AUTHERROR:
  118.         err = auth_errmsg(e.re_why);
  119.         (void) sprintf(str,"; why = ");
  120.         str += strlen(str);
  121.         if (err != NULL) {
  122.             (void) sprintf(str, "%s",err);
  123.         } else {
  124.             (void) sprintf(str,
  125.                 "(unknown authentication error - %d)",
  126.                 (int) e.re_why);
  127.         }
  128.         str += strlen(str);
  129.         break;
  130.  
  131.     case RPC_PROGVERSMISMATCH:
  132.         (void) sprintf(str, 
  133.             "; low version = %lu, high version = %lu", 
  134.             e.re_vers.low, e.re_vers.high);
  135.         str += strlen(str);
  136.         break;
  137.  
  138.     default:    /* unknown */
  139.         (void) sprintf(str, 
  140.             "; s1 = %lu, s2 = %lu", 
  141.             e.re_lb.s1, e.re_lb.s2);
  142.         str += strlen(str);
  143.         break;
  144.     }
  145.     (void) sprintf(str, "\n");
  146.     return(strstart) ;
  147. }
  148.  
  149. void
  150. clnt_perror(rpch, s)
  151.     CLIENT *rpch;
  152.     char *s;
  153. {
  154.     (void) fprintf(stderr,"%s",clnt_sperror(rpch,s));
  155. }
  156.  
  157.  
  158. struct rpc_errtab {
  159.     enum clnt_stat status;
  160.     char *message;
  161. };
  162.  
  163. static struct rpc_errtab  rpc_errlist[] = {
  164.     { RPC_SUCCESS, 
  165.         "RPC: Success" }, 
  166.     { RPC_CANTENCODEARGS, 
  167.         "RPC: Can't encode arguments" },
  168.     { RPC_CANTDECODERES, 
  169.         "RPC: Can't decode result" },
  170.     { RPC_CANTSEND, 
  171.         "RPC: Unable to send" },
  172.     { RPC_CANTRECV, 
  173.         "RPC: Unable to receive" },
  174.     { RPC_TIMEDOUT, 
  175.         "RPC: Timed out" },
  176.     { RPC_VERSMISMATCH, 
  177.         "RPC: Incompatible versions of RPC" },
  178.     { RPC_AUTHERROR, 
  179.         "RPC: Authentication error" },
  180.     { RPC_PROGUNAVAIL, 
  181.         "RPC: Program unavailable" },
  182.     { RPC_PROGVERSMISMATCH, 
  183.         "RPC: Program/version mismatch" },
  184.     { RPC_PROCUNAVAIL, 
  185.         "RPC: Procedure unavailable" },
  186.     { RPC_CANTDECODEARGS, 
  187.         "RPC: Server can't decode arguments" },
  188.     { RPC_SYSTEMERROR, 
  189.         "RPC: Remote system error" },
  190.     { RPC_UNKNOWNHOST, 
  191.         "RPC: Unknown host" },
  192.     { RPC_UNKNOWNPROTO,
  193.         "RPC: Unknown protocol" },
  194.     { RPC_PMAPFAILURE, 
  195.         "RPC: Port mapper failure" },
  196.     { RPC_PROGNOTREGISTERED, 
  197.         "RPC: Program not registered"},
  198.     { RPC_FAILED, 
  199.         "RPC: Failed (unspecified error)"}
  200. };
  201.  
  202.  
  203. /*
  204.  * This interface for use by clntrpc
  205.  */
  206. char *
  207. clnt_sperrno(stat)
  208.     enum clnt_stat stat;
  209. {
  210.     int i;
  211.  
  212.     for (i = 0; i < sizeof(rpc_errlist)/sizeof(struct rpc_errtab); i++) {
  213.         if (rpc_errlist[i].status == stat) {
  214.             return (rpc_errlist[i].message);
  215.         }
  216.     }
  217.     return ("RPC: (unknown error code)");
  218. }
  219.  
  220. void
  221. clnt_perrno(num)
  222.     enum clnt_stat num;
  223. {
  224.     (void) fprintf(stderr,"%s",clnt_sperrno(num));
  225. }
  226.  
  227.  
  228. char *
  229. clnt_spcreateerror(s)
  230.     char *s;
  231. {
  232.     extern int sys_nerr;
  233.     extern char *sys_errlist[];
  234.     char *str = _buf();
  235.  
  236.     if (str == 0)
  237.         return(0);
  238.     (void) sprintf(str, "%s: ", s);
  239.     (void) strcat(str, clnt_sperrno(rpc_createerr.cf_stat));
  240.     switch (rpc_createerr.cf_stat) {
  241.     case RPC_PMAPFAILURE:
  242.         (void) strcat(str, " - ");
  243.         (void) strcat(str,
  244.             clnt_sperrno(rpc_createerr.cf_error.re_status));
  245.         break;
  246.  
  247.     case RPC_SYSTEMERROR:
  248.         (void) strcat(str, " - ");
  249.         if (rpc_createerr.cf_error.re_errno > 0
  250.             && rpc_createerr.cf_error.re_errno < sys_nerr)
  251.             (void) strcat(str,
  252.                 sys_errlist[rpc_createerr.cf_error.re_errno]);
  253.         else
  254.             (void) sprintf(&str[strlen(str)], "Error %d",
  255.                 rpc_createerr.cf_error.re_errno);
  256.         break;
  257.     }
  258.     (void) strcat(str, "\n");
  259.     return (str);
  260. }
  261.  
  262. void
  263. clnt_pcreateerror(s)
  264.     char *s;
  265. {
  266.     (void) fprintf(stderr,"%s",clnt_spcreateerror(s));
  267. }
  268.  
  269. struct auth_errtab {
  270.     enum auth_stat status;    
  271.     char *message;
  272. };
  273.  
  274. static struct auth_errtab auth_errlist[] = {
  275.     { AUTH_OK,
  276.         "Authentication OK" },
  277.     { AUTH_BADCRED,
  278.         "Invalid client credential" },
  279.     { AUTH_REJECTEDCRED,
  280.         "Server rejected credential" },
  281.     { AUTH_BADVERF,
  282.         "Invalid client verifier" },
  283.     { AUTH_REJECTEDVERF,
  284.         "Server rejected verifier" },
  285.     { AUTH_TOOWEAK,
  286.         "Client credential too weak" },
  287.     { AUTH_INVALIDRESP,
  288.         "Invalid server verifier" },
  289.     { AUTH_FAILED,
  290.         "Failed (unspecified error)" },
  291. };
  292.  
  293. static char *
  294. auth_errmsg(stat)
  295.     enum auth_stat stat;
  296. {
  297.     int i;
  298.  
  299.     for (i = 0; i < sizeof(auth_errlist)/sizeof(struct auth_errtab); i++) {
  300.         if (auth_errlist[i].status == stat) {
  301.             return(auth_errlist[i].message);
  302.         }
  303.     }
  304.     return(NULL);
  305. }
  306.